home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / gfx / show / MerlinGfx.lha / bitmap.h < prev    next >
C/C++ Source or Header  |  1995-06-07  |  8KB  |  192 lines
  1. /***********************************************************/
  2. /*      _  __ __                                           */
  3. /*  /_//_)/_ (                                             */
  4. /* / //( (_/__)|/STEM   written by H.Raaf © 1992-93        */
  5. /*             /                                           */
  6. /*                           ProDev / X-Pert               */
  7. /*                                                         */
  8. /***********************************************************/
  9. /*                                                         */
  10. /* Definitions for the HRBitMap V38                        */
  11. /*                                                         */
  12. /***********************************************************/
  13.  
  14. #ifndef HRG_BITMAP_H
  15. #define HRG_BITMAP_H
  16.  
  17. #ifndef EXEC_TYPES_H
  18. #include <exec/types.h>
  19. #endif
  20.  
  21. #ifndef EXEC_SEMAPHORES_H
  22. #include <exec/semaphores.h>
  23. #endif
  24.  
  25.  
  26. /*
  27. ** Color Look Up Table Definition, wird fuer die GAMMA Korrektur
  28. ** bei hrWriteRect() und andere Funktionen mit GAMMA Faehigkeit, anstelle
  29. ** der Stukture HRColorMap() verwendet! Bitte beachten das der Aufbau sich
  30. ** stark von einer HRColorMap unterscheidet (aus Geschwindikeitsgruenden
  31. ** ist es guenstiger die RGB(A) Werte nicht als ULONGs sondern in 4
  32. ** Array's zu haben (Spart viel Rechenzeit pro Pixel). Eine CLUT ist immer
  33. ** fuer alle 256 Farben pro Farbanteil definiert (siehe HRGRender.library).
  34. */
  35.  
  36. struct HRCLUT
  37. {
  38.     UBYTE R[256];
  39.     UBYTE G[256];
  40.     UBYTE B[256];
  41.     UBYTE A[256];
  42. };
  43.  
  44. struct HRBitMap
  45. {
  46.     union LOCKTYPE
  47.     {
  48.         struct SignalSemaphore BLock;    /* Die Signal Semaphore, welche vor Auslager Problemen schuetzt...*/
  49.         struct HRBitMap *LinkBMap;        
  50.     }    LockType;                            /* Damit wird die BitMap Struktur (und der durch sie belegte Speicher
  51.                                                 ** vor einer Veraenderung waehrend des Auslagerns geschuetzt.) */
  52.  
  53.     UWORD BytesPerRow;    /* Anzahl der Bytes um von einem Pixel, den naechsten Pixel eine Zeile
  54.                                 ** tiefer zu erreichen (Width aus HRScreen kann kleiner sein!) */
  55.     UWORD Rows;                /* Anzahl der Zeilen */
  56.     UWORD BitMapType;        /* Art des Hardware-Farbmodus der BitMap */
  57.     UBYTE    BitMapFlags;    /* Diese Flags geben Auskunft ueber die Art der BitMap */
  58.     UBYTE PixelModulo;    /* Bits um von einem Pixel zum naechsten zu gelangen:
  59.                                 ** (PixelModulo/8) = BytePerPixel in der Zeile (kann Bruchteil sein!)
  60.                                 ** Breite in Pixel = (BytesPerRow/PixelModulo)*8 (geht immer)
  61.                                 **
  62.                                 ** PLANE        :    1 (auf planes achten) (Nicht bei Merlin!)
  63.                                 ** PACKED    :    1,2,4,8 (Domino nur 8)
  64.                                 ** MIXED        :    4 (auf Byte Packed BitPlane Data achten,
  65.                                 **             da dieser Modus ganz SPEZIELL arbeitet)
  66.                                 ** XGA        :    16 (R:5 G:6 B:5) (Nicht bei Domino)
  67.                                 ** TARGA        :    16 (R:5 G:5 B:5)
  68.                                 ** RGB24        :    24 (R:8 G:8 B:8) (Nicht bei Domino)    */
  69.     UBYTE    *MemPtr[8];        /* Maximal 8 (Plane) Pointer
  70.                                 **
  71.                                 ** PLANE         :    0 oder 0-3 : wie Amiga BitPlanes (Nur Domino)
  72.                                 ** PACKED        :    0-7 (Je nach BitsPerPixel / sind aber alle gleich ;)
  73.                                 ** MIXED            :    0-3 (Zeigen jeweils auf x Plane Byte)
  74.                                 ** XGA            :    0 (1 Alpha Channel Daten 8 Bit)
  75.                                 ** TARGA            :    0 (1 Alpha Channel Daten 8 Bit)
  76.                                 ** RGB24            :    0 (1 Alpha Channel Daten 8 Bit) */
  77.     UBYTE *BaseMem;        /* Hier steht die Auslager Adresse fuer den Screen
  78.                                 ** Wenn diese nicht gesetzt ist, so gilt die BitMap
  79.                                 ** als nicht verlagerbar und je nach Flags ist sie
  80.                                 ** im Kartenspeicher oder halt nicht (USE WITH CARE!) */
  81.     ULONG ByteSize;        /* Number of Bytes in this BitMap */
  82.     union
  83.     {
  84.         struct HRColorMap *ColorMap;    /* Points to hrh->ColorMap in Palette Modi */
  85.         struct HRCLUT *CLUT;
  86.     } ColCLUT;
  87.  
  88.     UBYTE *BankAddress;    /* PRIVATE! Adresse des ersten Bytes in der naechsten Bank */
  89.     UBYTE RenderFlags;    /* Aus diesen Bits berechnet sich die RenderFunc.. */
  90.     UBYTE Bank;                /* PRIVATE! Aktual BANK (Bit 0 for ZorroII 4MB/2 Banking) */
  91.     UWORD    BankedLine;        /* PRIVATE! Zeile in der gebankt werden muss */
  92.     UWORD    BankedByte;        /* PRIVATE! Offset des Bytes bei dem gebankt werden muss */
  93.     UWORD    WordReserved;    /* PRIVATE! */
  94. };
  95.  
  96. #define BLock            LockType.BLock
  97. #define LinkBitMap    LockType.LinkMap
  98. #define LinkLock        LockType.LinkMap->BLock
  99.  
  100. /* Definitionen fuer HRBitMap Type */
  101.  
  102. /* Bits Per Pixel in der BitMap (und Depth bei Planes)
  103. **
  104. ** PLANE        :    1 und 4 (Nicht bei Merlin!)
  105. ** PACKED    :    1-8 (Domino nur 8)
  106. ** MIXED        :    4    (Byte Packed BitPlane Data)
  107. ** XGA        :    16 (R:5 G:6 B:5) (Nicht bei Domino)
  108. ** TARGA        :    15 (R:5 G:5 B:5)
  109. ** RGB24        :    24 (R:8 G:8 B:8) (Nicht bei Domino)
  110. */
  111.  
  112. #define HRBM_MODEMASK    0xFF00
  113. #define HRBM_BITMASK        0x00FF
  114.  
  115. #define HRBM_PLANE    0    /* Nicht bei Merlin */
  116. #define HRBM_PACKED    1
  117. #define HRBM_MIXED    2
  118. #define HRBM_XGA        3    /* Nicht bei Domino */
  119. #define HRBM_TARGA    4
  120. #define HRBM_RGB24    5    /* Nicht bei Domino */
  121. #define HRBM_RGBOVL    6    /* z.Z. nicht implementiert */
  122.  
  123. #define HRCOL_PLANE4        (HRBM_PLANE<<8|4)        /* Nicht bei Merlin */
  124. #define HRCOL_MIXED4        (HRBM_MIXED<<8|4)
  125. #define HRCOL_PACKED1    (HRBM_PACKED<<8|1)    /* z.Z. nicht implementiert */
  126. #define HRCOL_PACKED2    (HRBM_PACKED<<8|2)    /* z.Z. nicht implementiert */
  127. #define HRCOL_PACKED4    (HRBM_PACKED<<8|4)    /* z.Z. nicht implementiert */
  128. #define HRCOL_PACKED8    (HRBM_PACKED<<8|8)
  129. #define HRCOL_TARGA        (HRBM_TARGA<<8|15)
  130. #define HRCOL_XGA            (HRBM_XGA<<8|16)        /* Nicht bei Domino */
  131. #define HRCOL_RGB24        (HRBM_RGB24<<8|24)    /* Nicht bei Domino */
  132. #define HRCOL_RGBOVL        (HRBM_RGBOVL<<8|32)    /* z.Z. nicht implementiert */
  133.  
  134. /* This Definitions are not fully Clear... but nice ;) */
  135.  
  136. #define HRCOL_16Col        HRCOL_PLANE4            /* Obsolete */
  137. #define HRCOL_256Col        HRCOL_PACKED8            /* Obsolete */
  138. #define HRCOL_HiCol        HRCOL_TARGA                /* Obsolete */
  139.  
  140.  
  141. /* This Definitions for advanced BitMap prozessing */
  142.  
  143. #define HRBRF_ALL            0xFF
  144. #define HRBRB_DITHER        0    /* Dither Modus aktive, wird nur bei TARGA, XGA
  145.                                     ** und PACKED8 unterstuetzt. */
  146.  
  147. #define HRBRB_USERGBA    1    /* Wenn dieses Flags gesetzt ist, wird bei PACKED8
  148.                                     ** ein Farbwert fuer die HRGRenderLibrary als 24 Bit
  149.                                     ** Wert interpretiert
  150.                                     ** Bei den Funktionen, welche RGBA DATEN erwarten,
  151.                                     ** bewirkt dieses Flag, das die SOURCE Daten als
  152.                                     ** RGBA (ULONG) Daten erwartet werden (spez. fuer
  153.                                     ** hrWriteRect() einzusetzten (HRBRB_QUICKRGBA) */
  154.  
  155. #define HRBRB_USECLUT    2    /* Wenn dieses Flags gesetzt ist, wird bei Palettenlosen
  156.                                     ** Modi der Eintrag aus hrbm->CLUT bzw. hrbm->ColorMap
  157.                                     ** als Pseudo-Palette benutzt (HRBRB_USECMAP).
  158.                                     ** Bei Funktionen, welche RGBA DATEN erwarten, wird
  159.                                     ** bei gesetztem Flags eine ColorLookUp Table (z.B.
  160.                                     ** fuer GAMMA Korrektur) benutzt */
  161.  
  162. #define HRBRB_BANKED        3  /* Flag, welches gebankte BitMaps kennzeichnet !! */
  163.  
  164. #define HRBRF_DITHER        (1<<HRBRB_DITHER)
  165. #define HRBRF_USERGBA    (1<<HRBRB_USERGBA)
  166. #define HRBRF_USECLUT    (1<<HRBRB_USECLUT)
  167. #define HRBRF_BANKED        (1<<HRBRB_BANKED)
  168.  
  169. /* Defines fuer doppelt benutzte Flags */
  170.  
  171. #define HRBRB_QUICKRGBA    HRBRB_USERGBA
  172. #define HRBRF_QUICKRGBA    HRBRF_USERGBA
  173. #define HRBRB_USECMAP    HRBRB_USECLUT
  174. #define HRBRF_USECMAP    HRBRF_USECLUT
  175.  
  176. /* Definitionen fuer HRBitMap : Flags */
  177.  
  178. #define HRBFF_ALL            0xFF
  179. #define HRBFB_LINKMAP    0    /* Diese BitMap ist an eine andere BitMap gelinked */
  180.                                     /* Bei solchen BitMaps ist der BLock keine Signal-Semaphore,
  181.                                     ** sondern ein Zeiger auf die "Grund" BitMap. */
  182. #define HRBFB_BLITABLE    1    /* Bitmap ist BLITBAR */
  183. #define HRBFB_ACCABLE    2    /* Bitmap kann Hardware-Masken benutzen */
  184. #define HRBFB_FAKEMAP    3    /* Bitmap ist NIEMALS SICHTBAR */
  185.  
  186. #define HRBFF_LINKMAP    (1<<HRBFB_LINKMAP)
  187. #define HRBFF_BLITABLE    (1<<HRBFB_BLITABLE)
  188. #define HRBFF_ACCABLE    (1<<HRBFB_ACCABLE)
  189. #define HRBFF_FAKEMAP    (1<<HRBFB_FAKEMAP)
  190. #endif
  191.  
  192.